/**
 * 错误处理工具
 */

import { logger } from './logger'
import { useAppStore } from '@/stores/app'

// 错误类型枚举
export const ErrorTypes = {
  NETWORK_ERROR: 'NETWORK_ERROR',
  API_ERROR: 'API_ERROR',
  VALIDATION_ERROR: 'VALIDATION_ERROR',
  NOT_FOUND_ERROR: 'NOT_FOUND_ERROR',
  PERMISSION_ERROR: 'PERMISSION_ERROR',
  UNKNOWN_ERROR: 'UNKNOWN_ERROR'
}

// 错误消息映射
export const ErrorMessages = {
  [ErrorTypes.NETWORK_ERROR]: '网络连接错误，请检查网络设置',
  [ErrorTypes.API_ERROR]: '服务器错误，请稍后重试',
  [ErrorTypes.VALIDATION_ERROR]: '输入数据格式错误',
  [ErrorTypes.NOT_FOUND_ERROR]: '请求的资源不存在',
  [ErrorTypes.PERMISSION_ERROR]: '权限不足，无法执行此操作',
  [ErrorTypes.UNKNOWN_ERROR]: '未知错误，请联系管理员'
}

class ErrorHandler {
  constructor() {
    this.setupGlobalErrorHandlers()
  }

  // 设置全局错误处理器
  setupGlobalErrorHandlers() {
    // Vue错误处理
    window.addEventListener('error', (event) => {
      this.handleGlobalError(event.error, '全局JavaScript错误')
    })

    // Promise拒绝处理
    window.addEventListener('unhandledrejection', (event) => {
      this.handleGlobalError(event.reason, '未处理的Promise拒绝')
      event.preventDefault()
    })
  }

  // 处理全局错误
  handleGlobalError(error, context = '全局错误') {
    logger.error(`${context}:`, error)
    
    // 在生产环境中，可以发送错误报告到服务器
    if (import.meta.env.PROD) {
      this.reportError(error, context)
    }
  }

  // 处理API错误
  handleApiError(error, context = 'API请求') {
    let errorType = ErrorTypes.UNKNOWN_ERROR
    let message = ErrorMessages[ErrorTypes.UNKNOWN_ERROR]

    if (error.response) {
      // 服务器响应错误
      const status = error.response.status
      const data = error.response.data

      switch (status) {
        case 400:
          errorType = ErrorTypes.VALIDATION_ERROR
          message = data?.error?.message || ErrorMessages[ErrorTypes.VALIDATION_ERROR]
          break
        case 404:
          errorType = ErrorTypes.NOT_FOUND_ERROR
          message = data?.error?.message || ErrorMessages[ErrorTypes.NOT_FOUND_ERROR]
          break
        case 403:
        case 401:
          errorType = ErrorTypes.PERMISSION_ERROR
          message = data?.error?.message || ErrorMessages[ErrorTypes.PERMISSION_ERROR]
          break
        case 500:
        default:
          errorType = ErrorTypes.API_ERROR
          message = data?.error?.message || ErrorMessages[ErrorTypes.API_ERROR]
          break
      }
    } else if (error.request) {
      // 网络错误
      errorType = ErrorTypes.NETWORK_ERROR
      message = ErrorMessages[ErrorTypes.NETWORK_ERROR]
    }

    const formattedError = {
      type: errorType,
      message,
      originalError: error,
      context,
      timestamp: new Date().toISOString()
    }

    logger.apiError(context, error.config?.url || '未知URL', formattedError)
    
    return formattedError
  }

  // 显示错误消息
  showError(error, duration = 5000) {
    const appStore = useAppStore()
    const message = typeof error === 'string' ? error : error.message
    
    appStore.setError(message)
    
    // 自动清除错误消息
    if (duration > 0) {
      setTimeout(() => {
        appStore.clearError()
      }, duration)
    }
  }

  // 报告错误到服务器（生产环境）
  reportError(error, context) {
    // 这里可以实现错误上报逻辑
    // 例如发送到错误监控服务
    console.log('错误上报:', { error, context })
  }

  // 创建用户友好的错误消息
  createUserFriendlyMessage(error) {
    if (typeof error === 'string') {
      return error
    }

    if (error.type && ErrorMessages[error.type]) {
      return ErrorMessages[error.type]
    }

    if (error.message) {
      return error.message
    }

    return ErrorMessages[ErrorTypes.UNKNOWN_ERROR]
  }

  // 处理表单验证错误
  handleValidationError(errors) {
    if (Array.isArray(errors)) {
      return errors.map(error => ({
        field: error.field,
        message: error.message
      }))
    }

    if (typeof errors === 'object') {
      return Object.keys(errors).map(field => ({
        field,
        message: errors[field]
      }))
    }

    return [{ field: 'general', message: '表单验证失败' }]
  }
}

// 创建全局错误处理实例
export const errorHandler = new ErrorHandler()

// 导出错误处理类
export default ErrorHandler
